const Type = require('../models/typeModel'); // 确保路径正确

// 获取所有类型
const gets = async (req, res) => {
    try {
        const types = await Type.find().sort({ timestamp: -1 }).lean();

        const modifiedTypes = types.map((item, index) => ({
            index: index + 1, // 添加序号，从1开始
            ...item,
        }));

        res.json({ code: 0, status: 'success', message: '获取类型成功', data: modifiedTypes });
    } catch (error) {
        res.status(500).json({ message: '获取类型失败', error: error.message });
    }
};

// 添加新类型
const add = async (req, res) => {
    const { typeName } = req.body;

    if (!typeName) {
        return res.status(400).json({ message: '类型名称不能为空' });
    }

    try {
        const type = new Type({ typeName });
        await type.save();
        res.status(201).json(type);
    } catch (error) {
        let errorMessage = error.message;
        if (error.name === 'MongoError' && error.code === 11000) {
            errorMessage = '已存在相同类型名称';
        }
        res.status(500).json({ message: '添加类型失败', error: errorMessage });
    }
};

// 更新类型
const mongoose = require('mongoose');

// 更新类型
const updateTypes = async (req, res) => {
    const { typeInfos } = req.body; // 新的 typeInfo 数组

    console.log(typeInfos)

    if (!Array.isArray(typeInfos) || typeInfos.length === 0) {
        return res.status(400).json({ message: 'typeInfos 必须是一个非空数组' });
    }

    try {
        const updates = await Promise.all(
            typeInfos.map(async ({ _id, typeName, bindAccountNum }) => {
                const type = await Type.findById(new mongoose.Types.ObjectId(_id));
                if (!type) {
                    return { message: '类型未找到' };
                }

                type.typeName = typeName !== undefined ? typeName : type.typeName;
                type.bindAccountNum = bindAccountNum !== undefined ? bindAccountNum : type.bindAccountNum;
                const updatedType = await type.save();
                return updatedType;
            })
        );

        res.json(updates);
    } catch (error) {
        res.status(500).json({ message: '更新类型失败', error: error.message });
    }
};

// 删除类型
const deleteTypes = async (req, res) => {
    const { typeIds } = req.body; // 使用 typeIds 代替 typeNames

    if (!Array.isArray(typeIds) || typeIds.length === 0) {
        return res.status(400).json({ message: '未选择类型' });
    }

    try {
        // 转换 typeIds 为 ObjectId 类型
        const objectIds = typeIds.map(id => new mongoose.Types.ObjectId(id));
        const result = await Type.deleteMany({ _id: { $in: objectIds } });

        if (result.deletedCount === 0) {
            return res.status(404).json({ message: '没有找到匹配的类型' });
        }

        res.json({ message: `${result.deletedCount} 个类型已删除` });
    } catch (error) {
        res.status(500).json({ message: '删除类型失败', error: error.message });
    }
};

module.exports = { gets, add, updateTypes, deleteTypes };
